
package utilitario;

import br.edu.unipampa.campeonato.Campeonato;
import br.edu.unipampa.campeonato.MercadoDeTransferencias;
import br.edu.unipampa.campeonato.PartidaDeFutebol;
import br.edu.unipampa.clube.Clube;
import br.edu.unipampa.clube.Tecnico;
import java.util.ArrayList;
import java.util.Scanner;

/**
 * @author Antoni, Gean, Vinicius
 * matricula 121150124,121151418, 121151385
 * @version 1.1
 * @since 8/03/13
 */
public class EntradaDeDados {
    private Scanner teclado;                                              //Variavel do scanner, para interaçoes
    private String escolha;                                               //String para o armazenamento de interaçoes
    
    /*
     * Método que construtor da classe que inicializa a variavel Scanner
     */
    public EntradaDeDados() {
        teclado = new Scanner(System.in);
    }

    /**
     * Um dos métodos principais do jogo, esse menu estara constantemente sendo apresentado
     * para o usuario, e é nele que o usuario interage com o jogo, consulta os jogadores de 
     * seu clube, escala o time, vê a escalaçao do time rival(time que enfrentará), vai para
     * a partida, consulta o mercado de transferencias, compra e vende jogadores e vê sua 
     * situaçao e dos outros times no campeonato
     * 
     * @param tecnico, do tipo Tecnico
     * @param partida, do tipo PartidaDeFutebol
     * @param mercado, do tipo MercadoDeTransferencias
     * @param camp, do tipo Campeonato
     * @return menu, do tipo String
     */
    public String menu(Tecnico tecnico, PartidaDeFutebol partida, MercadoDeTransferencias mercado, Campeonato camp) {
        System.out.println("\nTecle '1' para *consultar os jogadores de seu clube* \nTecle '2' para *escalar o time* \nTecle '3' para *ver equipe"
                + " rival do proximo jogo* \nTecle '4' para *ir para a partida* \nTecle '5' para *consultar o mercado de transferencias* "
                + "\nTecle '6' para *comprar jogador* \nTecle '7' para *vender jogador* \nTecle '8' para *ver tabela do campeonato*");
        escolha = teclado.next();

        switch (escolha) {
            case "1":
                tecnico.consultarJogadoresDoClube();
                return menu(tecnico, partida, mercado, camp);
            case "2":
                int numTitular,
                 numReserva = 0;
                tecnico.escalarTime();
                numTitular = Integer.parseInt(escolherJogadorTitular());
                numReserva = Integer.parseInt(escolherJogadorReserva());
                tecnico.substituirNaEscalacao(numTitular, numReserva);
                return menu(tecnico, partida, mercado, camp);
            case "3":
                tecnico.consultarJogadoresDoClube(tecnico.getClubeQueDirige().getClubeQueEnfrenta());
                return menu(tecnico, partida, mercado, camp);
            case "4":
                if (camp.getNumeroDaRodada() != 8) {
                    partida.jogarPrimeiroTempo();
                    intervalo(tecnico, partida);
                    camp.setNumeroDaRodada(camp.getNumeroDaRodada() + 1);
                    ArrayList<Clube> clubesParaSimulacao = partida.clubesSimulacao();
                    System.out.println("\n---------- Resultado dos Outros Jogos ------------");
                    partida.simulaOutrosJogos(clubesParaSimulacao.get(0), clubesParaSimulacao.get(1));
                    partida.simulaOutrosJogos(clubesParaSimulacao.get(2), clubesParaSimulacao.get(3));
                    partida.simulaOutrosJogos(clubesParaSimulacao.get(4), clubesParaSimulacao.get(5));
                    if (camp.getNumeroDaRodada() == 2) {
                        camp.tabelaSegundaRodada();
                    } else if (camp.getNumeroDaRodada() == 3) {
                        camp.tabelaTerceiraRodada();
                    } else if (camp.getNumeroDaRodada() == 4) {
                        camp.tabelaQuartaRodada();
                    } else if (camp.getNumeroDaRodada() == 5) {
                        camp.tabelaQuintaRodada();
                    } else if (camp.getNumeroDaRodada() == 6) {
                        camp.tabelaSextaRodada();
                    } else {
                        camp.tabelaSetimaRodada();
                    }
                } else {
                    System.out.println("********* Não há mais jogos!!! Fim da Temporada *********");
                    int contadorDePontos = 0;
                    int numClube = 0;
                    Clube vencedor = null;
                    while (numClube != 8) {
                        for (int i = 0; i < camp.getClubes().size(); i++) {
                            if (!camp.getClubes().get(numClube).equals(camp.getClubes().get(i))) {
                                if (camp.getClubes().get(numClube).getPontos() > camp.getClubes().get(i).getPontos()) {
                                    contadorDePontos++;
                                }
                            }
                        }
                        if (contadorDePontos == 7) {
                            vencedor = camp.getClubes().get(numClube);
                        }
                        numClube++;
                    }
                    try {
                        System.out.println("Clube Campeão "+vencedor.getNome());
                    } catch (Exception e) {
                        System.out.println("Mais de um clube CAMPEAO =/");
                    }
                }

                return menu(tecnico, partida, mercado, camp);
            case "5":
                tecnico.consultarMercado(mercado);
                return menu(tecnico, partida, mercado, camp);
            case "6":
                System.out.println("\nDinheiro em caixa do clube: R$ " + tecnico.getClubeQueDirige().getDinheiroEmCaixa());
                System.out.println("\nDigite o nome do jogador que deseja comprar: ");
                escolha = teclado.next();
                tecnico.comprarJogador(mercado, escolha);
                return menu(tecnico, partida, mercado, camp);
            case "7":
                System.out.println("\nDinheiro em caixa do clube: R$ " + tecnico.getClubeQueDirige().getDinheiroEmCaixa());
                System.out.println("\nDigite o nome do jogador que deseja vender: ");
                escolha = teclado.next();
                String temp = escolha;
                System.out.println("\nDigite o numero correspondente ao clube em que o jogador será vendido");
                Clube c = mostraEquipes(camp);

                escolha = teclado.next();
                tecnico.venderJogador(temp, c);
                return menu(tecnico, partida, mercado, camp);
            case "8":
                camp.tabelaDeClassificacao();
                return menu(tecnico, partida, mercado, camp);
            default:
                System.out.println("Digito Inválido!!! Tecle novamente");
                return menu(tecnico, partida, mercado, camp);
        }
     }

    /**
     * Método que exibe os clubes do campeonato e algumas informaçoes deles, e
     * pede ao usuario que escolha um deles para começar a partida
     * 
     * @param campeonato, do tipo Campeonato
     * @return escolha, do tipo String
     */
    public String definirClube(Campeonato campeonato) {
        System.out.println("**************************** Bem Vindo ao FootBall Manager ES *****************************");
        System.out.println("--------- A primeira coisa a fazer é definir qual clube você irá treinar --------");
        for (int i = 0; i < campeonato.getClubes().size(); i++) {
            System.out.println(i + " - " + campeonato.getClubes().get(i).getNome() + " ------- Grana R$:" + campeonato.getClubes().get(i).getDinheiroEmCaixa()
                    + " Força Média: " + campeonato.getClubes().get(i).getForcaMedia());
        }
        escolha = teclado.next();
        switch (escolha) {
            case "0":
                System.out.println("Parabéns!! Você é o novo técnico do Barcelona");
                return escolha;
            case "1":
                System.out.println("Parabéns!! Você é o novo técnico do Real Madrid");
                return escolha;
            case "2":
                System.out.println("Parabéns!! Você é o novo técnico do Atletico de Madrid");
                return escolha;
            case "3":
                System.out.println("Parabéns!! Você é o novo técnico do Valencia");
                return escolha;
            case "4":
                System.out.println("Parabéns!! Você é o novo técnico do Real Sociedad");
                return escolha;
            case "5":
                System.out.println("Parabéns!! Você é o novo técnico do VillaReal");
                return escolha;
            case "6":
                System.out.println("Parabéns!! Você é o novo técnico do Real Betis");
                return escolha;
            case "7":
                System.out.println("Parabéns!! Você é o novo técnico do Osasuna");
                return escolha;
            default:
                System.out.println("Digito Inválido!!! Tecle novamente");
                return definirClube(campeonato);
        }
    }

    
    //Método que substitui um jogador titular, é usado em conjunto com outros metodos
    public String escolherJogadorTitular() {
        String escolheJogadorTimeTitular;
        System.out.println("\nDigite o numero do jogador do time 'TITULAR' que deseja substituir: ");
        escolheJogadorTimeTitular = teclado.next();
        switch (escolheJogadorTimeTitular) {
            case "0":
                return escolheJogadorTimeTitular;
            case "1":
                return escolheJogadorTimeTitular;
            case "2":
                return escolheJogadorTimeTitular;
            case "3":
                return escolheJogadorTimeTitular;
            case "4":
                return escolheJogadorTimeTitular;
            case "5":
                return escolheJogadorTimeTitular;
            case "6":
                return escolheJogadorTimeTitular;
            case "7":
                return escolheJogadorTimeTitular;
            case "8":
                return escolheJogadorTimeTitular;
            case "9":
                return escolheJogadorTimeTitular;
            case "10":
                return escolheJogadorTimeTitular;
            default:
                System.out.println("Digite um valor válido!!!");
                return escolherJogadorTitular();
        }
    }

    //Método que substitui um jogador reserva, é usado em conjunto com outros metodos
    public String escolherJogadorReserva() {
        String escolheJogadorTimeReserva;
        System.out.println("\nDigite o numero do jogador do time 'RESERVA' que deseja substituir: ");
        escolheJogadorTimeReserva = teclado.next();
        switch (escolheJogadorTimeReserva) {
            case "0":
                return escolheJogadorTimeReserva;
            case "1":
                return escolheJogadorTimeReserva;
            case "2":
                return escolheJogadorTimeReserva;
            case "3":
                return escolheJogadorTimeReserva;
            case "4":
                return escolheJogadorTimeReserva;
            case "5":
                return escolheJogadorTimeReserva;
            case "6":
                return escolheJogadorTimeReserva;

            default:
                System.out.println("Digite um valo válido!!!");
                return escolherJogadorReserva();
        }
    }

    /**
     * Método que mostra as equipes do campeonato, é usado em conjunto com outros metodos
     * 
     * @param camp, do tipo Campeonato
     * @return camp.getClubes.get(index), do tipo Clube
     */
    public Clube mostraEquipes(Campeonato camp) {
        for (int i = 0; i < camp.getClubes().size(); i++) {
            System.out.println(i + " - " + camp.getClubes().get(i).getNome() + "\n");
        }
        escolha = teclado.next();
        switch (escolha) {
            case "0":
                return camp.getClubes().get(0);
            case "1":
                return camp.getClubes().get(1);
            case "2":
                return camp.getClubes().get(2);
            case "3":
                return camp.getClubes().get(3);
            case "4":
                return camp.getClubes().get(4);
            case "5":
                return camp.getClubes().get(5);
            case "6":
                return camp.getClubes().get(6);
            case "7":
                return camp.getClubes().get(7);
            default:
                System.out.println("Invalido");
                return null;
        }
    }

    /**
     * Método chamado entre os metodos "JogarPrimeiroTempo" e "JogarSegundoTempo", é realmente
     * o intervalo da partida, onde disponibiliza ao jogador opçoes como, substituir jogadores,
     * consultar informaçoes do adversario e voltar ao jogo.
     * 
     * @param tecnico, do tipo Tecnico
     * @param partida, do tipo PartidaDeFutebol
     * @return intervalo, do tipo int
     */
    private int intervalo(Tecnico tecnico, PartidaDeFutebol partida) {
        System.out.println("****************** Intervalo de Jogo ******************");
        System.out.println("Tecle '1' para Substituiçoes - tecle '2' para consultar o informações do time adversário"
                + " - tecle '3' para jogar o Segunto Tempo");
        escolha = teclado.next();
        switch (escolha) {
            case "1":
                int numTitular,
                 numReserva = 0;
                tecnico.escalarTime();
                numTitular = Integer.parseInt(escolherJogadorTitular());
                numReserva = Integer.parseInt(escolherJogadorReserva());
                tecnico.substituirNaEscalacao(numTitular, numReserva);
                return intervalo(tecnico, partida);
            case "2":
                tecnico.consultarJogadoresDoClube(tecnico.getClubeQueDirige().getClubeQueEnfrenta());
                return intervalo(tecnico, partida);
            case "3":
                partida.jogarSeguntoTempo();

                break;
            default:
                System.out.println("Digito Inválido!!! Tente novamente..");
                return intervalo(tecnico, partida);
        }
        return 0;
    }
}
